#include <iostream>
#include <string>
#include <pthread.h>
#include <unistd.h>
#include "mymutex.hpp"
#include "mythread.hpp"
using namespace std;

// int num = 10000;
// pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER; //全局互斥量

// class ThreadData //线程参数
// {
// public:
//     ThreadData() {}
//     ThreadData(const string &name, pthread_mutex_t *mutex)
//         : _name(name), _mutex(mutex)
//     {
//     }
//     string _name;
//     pthread_mutex_t *_mutex;
// };

// void *fun(void *args) // 没加锁造成num变成-1
// {
//     ThreadData *data = static_cast<ThreadData *>(args); //线程参数打包发送
//     while (true)
//     {
//         {
//             //pthread_mutex_lock(data->_mutex);
//             //lock m(data->_mutex);
//             if (num > 0)
//             {
//                 usleep(500);
//                 cout << data->_name << num-- << endl;
//                 //pthread_mutex_unlock(data->_mutex);
//             }
//             else
//             {
//                 //pthread_mutex_unlock(data->_mutex);
//                 break;
//             }
//             usleep(1000);

//         }

//     }
//     return args;
// }

// int main()
// {
//     pthread_t t[4] = {0};
//     pthread_mutex_t mutex;
//     pthread_mutex_init(&mutex, nullptr); // 初始化局部互斥量
//     for (int i = 0; i < 4; ++i)
//     {
//         char buf[64] = {0};
//         snprintf(buf, sizeof(buf), "thread-%d:", i + 1);
//         ThreadData *thread = new ThreadData(buf, &mutex);
//         pthread_create(t + i, nullptr, fun, (void *)thread);
//     }

//     for (int i = 0; i < 4; ++i)
//     {
//         void *data = nullptr;
//         int n = pthread_join(t[i], &data);
//         if (n != 0)
//         {
//             cerr << "join" << i << "线程" << t[i] << "error" << endl;
//             exit(-1);
//         }
//         ThreadData *thdata = static_cast<ThreadData *>(data);
//         delete thdata;
//     }
//     pthread_mutex_destroy(&mutex); // 销毁互斥量
//     return 0;
// }

// void* fun(void* args)
// {
//     const char* s = static_cast<const char*>(args);
//     for(int i = 0;i<5;++i)
//     {
//         cout<<s<<endl;
//         sleep(1);
//     }
//     return args;
// }

// int main()
// {
//     Thread t[4];
//     for (int i = 0; i < 4; ++i)
//     {
//         char buf[64] = {0};
//         snprintf(buf, sizeof(buf), "thread-%d:", i + 1);
//         ThreadData *thread = new ThreadData(buf, &m);
//         t[i] = Thread(buf,fun,(void*)thread);
//         t[i].run();
//     }

//     for (int i = 0; i < 4; ++i)
//     {
//         void* ret = nullptr;
//         ret = t[i].join();
//         delete (ThreadData*)ret;
//     }

//     return 0;
// }



//其他线程可以未申请锁但可以释放锁
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void* func(void* args)
{
    pthread_mutex_lock(&mutex);
    cout<<"其他thread申请锁"<<endl;
    pthread_mutex_lock(&mutex); //申请两次锁 第二次死锁
    cout<<"已解锁！"<<endl;
    pthread_mutex_unlock(&mutex);
    return nullptr;
}

int main()
{
    pthread_t t;
    pthread_create(&t,nullptr,func,nullptr);
    sleep(3);
    cout<<"主线程释放锁"<<endl;
    pthread_mutex_unlock(&mutex);
    sleep(1);
    return 0;
}